package com.tz.platform.utils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;

import org.apache.commons.lang3.StringUtils;

/**
 * 通用的函数(日期相关函数)
 *
 * @version 3.0
 */

public class DateUtil {
	// 每个月的天数
	static private int[] daysInMonth = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

	/**
	 * 获取SimpleDateFormat
	 * @param parttern 日期格式
	 * @return
	 * @throws RuntimeException
	 */
	private static SimpleDateFormat getDateFormat(String parttern) throws RuntimeException {
		return new SimpleDateFormat(parttern);
	}

	/**
	 * 日期/时间格式化显示（年、月、日、时、分、秒、毫秒、星期）
	 * @param strDate 需要格式化的日期
	 * @param strOldFormat 该日期的格式串
	 * @param strNewFormat 需要格式化的格式串
	 * @return 格式化后的字符串（String）
	 * @throws ParseException
	 */
	public static String msFormatDateTime(String strDate, String strOldFormat, String strNewFormat) throws ParseException {
		Date dtDate = new Date();
		if (strNewFormat.equals("") | strOldFormat.equals(""))
			strNewFormat = "yyyy-MM-dd HH:mm:ss";

		SimpleDateFormat myFormatter = new SimpleDateFormat(strNewFormat);
		myFormatter.setLenient(false);
		dtDate = new SimpleDateFormat(strOldFormat).parse(strDate);
		return myFormatter.format(dtDate.getTime());
	}

	/**
	 * 日期/时间格式化显示（年、月、日、时、分、秒、毫秒、星期）
	 *
	 * @param dtmDate  需要格式化的日期（java.util.Date）
	 * @param strFormat 该日期的格式串
	 * @return 格式化后的字符串（String）
	 */
	public static String msFormatDateTime(Date dtmDate, String strFormat) {
		if (strFormat.equals(""))
			strFormat = "yyyy-MM-dd HH:mm:ss";
		SimpleDateFormat myFormat = new SimpleDateFormat(strFormat);
		return myFormat.format(dtmDate.getTime());
	}

	/**
	 * 取得给定日期数天前（后）的日期函数
	 *
	 * @param strDate 需要进行加减的日期("yyyy-MM-dd")
	 * @param intStep 需要计算的间隔天数
	 * @return 返回计算后的日期（java.util.Date）
	 * @throws ParseException
	 */
	public static java.util.Date msInterDate(String strDate, int intStep) throws ParseException {

		String strFormat = "yyyy-MM-dd";
		java.util.Date dtDate = null;
		Calendar cal = Calendar.getInstance();
		SimpleDateFormat myFormatter = new SimpleDateFormat(strFormat);
		myFormatter.setLenient(false);
		dtDate = myFormatter.parse(strDate);
		cal.setTime(dtDate);
		cal.add(Calendar.DAY_OF_MONTH, intStep);
		return cal.getTime();
	}

	/**
	 * 取得给定日期数天前（后）的日期函数
	 *
	 * @param strDate 需要进行加减的日期("yyyy-MM-dd")
	 * @param intStep 需要计算的间隔天数
	 * @return 返回计算后的日期（String）
	 * @throws ParseException
	 */
	public static String msInterDateString(String strDate, int intStep) throws ParseException {
		String strFormat = "yyyy-MM-dd";
		java.util.Date dtDate = null;
		Calendar cal = Calendar.getInstance();
		SimpleDateFormat myFormatter = new SimpleDateFormat(strFormat);
		myFormatter.setLenient(false);
		dtDate = myFormatter.parse(strDate);

		cal.setTime(dtDate);
		cal.add(Calendar.DAY_OF_MONTH, intStep);

		return msFormatDateTime(cal.getTime(), "yyyy-MM-dd");
	}

	/**
	 * 日期比较
	 *
	 * @param strDate1 需要进行计较的日期1(yyyy-MM-dd)
	 * @param strDate2 需要进行计较的日期2(yyyy-MM-dd)
	 * @return 比较的结果（int） -1：strDate1 < strDate2 0：strDate1 = strDate2  1：strDate1 > strDate2
	 * @throws ParseException
	 */
	public static int msCompareDate(String strDate1, String strDate2) {
		try {
			String strFormat = "yyyy-MM-dd";
			java.util.Date dtDate1 = null;
			java.util.Date dtDate2 = null;
			int intCom = 0;
			SimpleDateFormat myFormatter = new SimpleDateFormat(strFormat);
			myFormatter.setLenient(false);
			dtDate1 = myFormatter.parse(strDate1);
			dtDate2 = myFormatter.parse(strDate2);

			intCom = dtDate1.compareTo(dtDate2);
			if (intCom > 0)
				return 1;
			if (intCom < 0)
				return -1;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return 0;
	}

	/**
	 * 获得日期的星期
	 * @param strDate 需要计算星期的日期(yyyy-MM-dd)
	 * @return 计算后的星期（int）
	 * @throws ParseException
	 */
	public static int msGetWeeks(String strDate) throws ParseException {
		String strFormat = "yyyy-MM-dd";
		java.util.Date dtDate = null;
		int intDay = 0;
		SimpleDateFormat myFormatter = new SimpleDateFormat(strFormat);
		Calendar cal = Calendar.getInstance();

		dtDate = myFormatter.parse(strDate);
		cal.setTime(dtDate);
		intDay = cal.get(Calendar.DAY_OF_WEEK) - 1;
		if (intDay == 0)
			intDay = 7;
		return intDay;
	}

	/**
	 * 获得给定月份的星期数,以星期日为一周的第一天
	 *
	 * @param strMonth 需要计算星期的日期(yyyy-MM-dd)
	 * @return 计算后的星期数（int）
	 * @throws ParseException
	 */
	public static int msGetWeeksofMonth(String strMonth) throws ParseException {
		String strFormat = "yyyy-MM-dd";
		int intDays = msGetDaysofMonth(strMonth);
		String strDays = strMonth.substring(0, 8) + String.valueOf(intDays);
		java.util.Date dtDate = null;
		int intWeeks = 0;
		SimpleDateFormat myFormatter = new SimpleDateFormat(strFormat);
		Calendar cal = Calendar.getInstance();

		dtDate = myFormatter.parse(strDays);

		cal.setTime(dtDate);
		intWeeks = cal.get(Calendar.WEEK_OF_MONTH);

		return intWeeks;
	}

	/**
	 * 获得给定月份的天数
	 * @param strMonth  月份
	 * @return 计算后的天数（int）
	 */
	public static int msGetDaysofMonth(String strMonth) {
		int intReturn = 0;
		int intMonth = StringUtil.msReturnInt(strMonth.substring(5, 7));
		switch (intMonth) {
		case 1:
			intReturn = daysInMonth[0];
			break;
		case 2:
			intReturn = daysInMonth[1];
			break;
		case 3:
			intReturn = daysInMonth[2];
			break;
		case 4:
			intReturn = daysInMonth[3];
			break;
		case 5:
			intReturn = daysInMonth[4];
			break;
		case 6:
			intReturn = daysInMonth[5];
			break;
		case 7:
			intReturn = daysInMonth[6];
			break;
		case 8:
			intReturn = daysInMonth[7];
			break;
		case 9:
			intReturn = daysInMonth[8];
			break;
		case 10:
			intReturn = daysInMonth[9];
			break;
		case 11:
			intReturn = daysInMonth[10];
			break;
		case 12:
			intReturn = daysInMonth[11];
			break;
		}
		int intYear = StringUtil.msReturnInt(strMonth.substring(0, 4));
		if (intYear % 4 == 0 && intYear % 100 != 0 || intYear % 400 == 0) {
			if (intMonth == 2)
				intReturn = 29;

		}
		return intReturn;
	}

	/**
	 * 获取当前日期、时间
	 * @return 系统当前的日期/时间（Date）
	 */
	public static Date msGetCurrentDate() {
		Date dtDate = new Date();
		return dtDate;
	}

	/**
	 * 返回格式化的当前日期/时间
	 *
	 * @param strFormat 格式串
	 * @return 当前日期/时间格式化后的字符串（String）
	 */
	public static String getFormatCurrentDate(String strFormat) {
		return msFormatDateTime(msGetCurrentDate(), strFormat);
	}

	/**
	 * 获得系统时间，格式自定义
	 * @param formatter
	 * @return
	 */
	public static String getCurrentTime(String formatter) {
		return DateUtil.getFormatCurrentDate(formatter);
	}

	/**
	 * 取上个工作日
	 *
	 * @param strFormat
	 *            (yyyy-MM-dd) 日期
	 * @return 上个工作日(yyyy-MM-dd)
	 * @throws ParseException
	 */
	public static String msGetLastWorkDate(String strFormat)
			throws ParseException {
		SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
		java.util.Date dtDate = null;
		Calendar cal = Calendar.getInstance();

		dtDate = myFormatter.parse(strFormat);
		cal.setTime(dtDate);
		do {
			cal.add(Calendar.DAY_OF_YEAR, -1);
		} while ((cal.get(Calendar.DAY_OF_WEEK) == 1)
				| (cal.get(Calendar.DAY_OF_WEEK) == 7));
		return myFormatter.format(cal.getTime());
	}

	/**
	 * 取得当前日期数天前（后）的日期函数
	 *
	 * @param intStep
	 *            间隔天数
	 * @return 计算后的日期（java.util.Date）
	 */
	public static java.util.Date msCurInterDate(int intStep) {
		Calendar cal = Calendar.getInstance();

		cal.setTime(new Date());
		cal.add(Calendar.DAY_OF_MONTH, intStep);

		return cal.getTime();
	}

	/**
	 * 两日期的间隔天数
	 * @return 间隔天数
	 * @throws ParseException
	 */
	public static long diffSecond(String strDateBegin, String strDateEnd) {
		long intDiff = 0;
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			Date dateBegin = sdf.parse(strDateBegin);
			Date dateEnd = sdf.parse(strDateEnd);

			long milliSencods = dateEnd.getTime() - dateBegin.getTime();
			intDiff = milliSencods / 1000;
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return intDiff;
	}

	/**
	 * 两日期的间隔天数
	 * @return 间隔天数（int）
	 * @throws ParseException
	 */
	public static int diffDay(String strDateBegin, String strDateEnd) {
		long milliSencods = diffSecond(strDateBegin, strDateEnd);
		long intDiff = milliSencods / (60 * 60 * 24);
		return (int) intDiff;
	}


	/**
	 * 两日期的间隔天数
	 * @return 间隔天数（int）
	 * @throws ParseException
	 */
	public static int diffDay(Date strDateBegin, Date strDateEnd) {
		long milliSencods =(strDateEnd.getTime() - strDateBegin.getTime())/1000;
		long intDiff = milliSencods / (60 * 60 * 24);
		return (int) intDiff;
	}

	/**
	 * 获取两个日期相差的月数,按一个月30天算
	 * @return 间隔月数（int）
	 * @throws ParseException
	 */
	public static int diffMonth(String strDateBegin, String strDateEnd)
			throws ParseException {
		long milliSencods = diffSecond(strDateBegin, strDateEnd);
		long intDiff = milliSencods / (60 * 60 * 24 * 30);
		return (int) intDiff;
	}

	/**
	 * 獲取連個日期相差的年數，一年365天算
	 *
	 * @return 间隔年数（int）
	 * @throws ParseException
	 */
	public static int diffYear(String strDateBegin, String strDateEnd)
			throws ParseException {
		long milliSencods = diffSecond(strDateBegin, strDateEnd);
		long intDiff = milliSencods / (60 * 60 * 24 * 365);
		return (int) intDiff;
	}

	/**
	 * 获取两个日期中的较大者
	 *
	 * @param strDate1 日期
	 * @param strDate2 日期
	 * @return 返回较大的日期
	 * @throws ParseException
	 */
	public static String msGetMaxTime(String strDate1, String strDate2) throws ParseException {
		int intTemp = msCompareDate(strDate1, strDate2);

		if (intTemp == -2)
			return "日期错误";
		if ((intTemp == 0) || (intTemp == 1)) {
			return strDate1;
		} else {
			return strDate2;
		}
	}

	/**
	 * 取得日期信息
	 *
	 * @return 当前日期
	 */
	public static String msGetToday() {
		Date curDate = new Date();
		SimpleDateFormat formatDate = new SimpleDateFormat("yyyy年MM月dd日");
		String strDate = formatDate.format(curDate);
		String[] weekdays = new String[] { "", "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
		Calendar cal = Calendar.getInstance();
		strDate = strDate + "&nbsp;&nbsp;"
				+ weekdays[cal.get(Calendar.DAY_OF_WEEK)];

		if (cal.get(Calendar.DAY_OF_WEEK) == 7) {
			strDate = "<font color='#b5ffb5'>" + strDate + "</font>";
		}
		if (cal.get(Calendar.DAY_OF_WEEK) == 1) {
			strDate = "<font color='#ffff80'>" + strDate + "</font>";
		}

		return strDate;
	}

	/**
	 * 取上一天
	 * @param strFormat (yyyy-MM-dd) 日期
	 * @return 上个工作日(yyyy-MM-dd)
	 * @throws ParseException
	 */
	public static String msGetLastDate(String strFormat) throws ParseException {
		SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
		java.util.Date dtDate = null;
		Calendar cal = Calendar.getInstance();

		dtDate = myFormatter.parse(strFormat);

		cal.setTime(dtDate);
		cal.add(Calendar.DAY_OF_YEAR, -1);

		return myFormatter.format(cal.getTime());
	}

	/**
	 * 取上个月
	 *
	 * @param strFormat  (yyyy-MM-dd) 日期
	 * @return 上个月(yyyy-MM-dd)
	 * @throws ParseException
	 */
	public static String msGetLastMonth(String strFormat) throws ParseException {
		SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy-MM-dd");
		java.util.Date dtDate = null;
		Calendar cal = Calendar.getInstance();

		dtDate = myFormatter.parse(strFormat);
		cal.setTime(dtDate);
		cal.add(Calendar.MONTH, -1);

		return myFormatter.format(cal.getTime());
	}

	/**
	 * 取得给定日期数月前后的日期函数
	 *
	 * @param strDate 需要进行加减的日期("yyyy-MM-dd")
	 * @param intMon 需要计算的间隔天数
	 * @return 返回计算后的日期（String）
	 * @throws ParseException
	 */
	public static String msDateAfterMonth(String strDate, int intMon)
			throws ParseException {
		String strFormat = "yyyy-MM-dd";
		java.util.Date dtDate = null;
		Calendar cal = Calendar.getInstance();
		SimpleDateFormat myFormatter = new SimpleDateFormat(strFormat);
		myFormatter.setLenient(false);
		dtDate = myFormatter.parse(strDate);
		cal.setTime(dtDate);
		cal.add(Calendar.MONTH, intMon);

		return msFormatDateTime(cal.getTime(), "yyyy-MM-dd");
	}

	/**
	 * 获得昨天
	 *
	 * @return
	 */
	public static Date getYesterday() {
		Calendar cal = Calendar.getInstance();
		cal.add(Calendar.DATE, -1);
		return cal.getTime();
	}

	/**
	 * 日期格式化
	 *
	 * @param pattern
	 * @param date
	 * @return
	 */
	public static String getParseDate(String pattern, Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat();
		sdf.applyPattern(pattern);
		return sdf.format(date);
	}

	/**
	 * 转换为日期
	 *
	 * @param dateStr
	 * @return
	 */
	public static Date toDate(String dateStr, String format) {
		Date date = new Date();
		if (StringUtils.isEmpty(dateStr)) {
			return date;
		}
		SimpleDateFormat formater = new SimpleDateFormat(format);
		if (dateStr.length() < format.length()) {
			formater = new SimpleDateFormat("yyyy-MM-dd");
		}
		try {
			date = formater.parse(dateStr);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}

	public static String formTimeString(String[] arr) {
		StringBuffer buf = new StringBuffer();
		if (1 == arr[2].length()) {
			buf.append("0");
			buf.append(arr[2]);
		} else {
			buf.append(arr[2]);
		}
		buf.append(":");
		if (1 == arr[1].length()) {
			buf.append("0");
			buf.append(arr[1]);
		} else {
			buf.append(arr[1]);
		}
		buf.append(":");
		if (1 == arr[0].length()) {
			buf.append("0");
			buf.append(arr[0]);
		} else {
			buf.append(arr[0]);
		}
		return buf.toString();
	}

	/**
	 * date 转换成str
	 *
	 * @param date
	 * @param formatStyle
	 * @return 格式化后的日期字符串
	 */
	public static String toString(Date date, String formatStyle) {
		SimpleDateFormat simple = new SimpleDateFormat(formatStyle);
		return simple.format(date);
	}

	public static String getTimeZone(Calendar cal, int day) {
		String date = "";
		try {
			if (cal.get(Calendar.MONTH) < 11) {
				if (cal.get(Calendar.DATE) + day > cal
						.getActualMaximum(Calendar.DAY_OF_MONTH)) {
					date = cal.get(Calendar.YEAR) + "年"
							+ (formatNum(cal.get(Calendar.MONTH) + 2)) + "月01日";
				} else {
					date = cal.get(Calendar.YEAR) + "年"
							+ (formatNum(cal.get(Calendar.MONTH) + 1)) + "月"
							+ (formatNum(cal.get(Calendar.DATE) + day)) + "日";
				}
			} else {
				if (cal.get(Calendar.DATE) >= cal
						.getActualMaximum(Calendar.DAY_OF_MONTH)) {
					date = (cal.get(Calendar.YEAR) + 1) + "年01月01日";
				} else {
					date = cal.get(Calendar.YEAR) + "年"
							+ (formatNum(cal.get(Calendar.MONTH) + 1)) + "月"
							+ (formatNum(cal.get(Calendar.DATE) + day)) + "日";
				}
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		return date;
	}

	public static Date getTZ(Calendar cal, int day) {
		Date d = new Date();
		SimpleDateFormat sdfTemp = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
		try {
			d = sdfTemp.parse(getTimeZone(cal, day) + " 00:00:00");
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return d;
	}

	/**
	 * 日期转换为指定格式的字符串
	 *
	 * @param d
	 * @return
	 */
	public static String formateDate(Date d,String format) {
		SimpleDateFormat sdfTemp = new SimpleDateFormat(format);
		return sdfTemp.format(d);
	}

	public static String formatNum(int num) {
		if (num < 10)
			return "0" + num;
		return Integer.valueOf(num).toString();
	}

	/**
	 * 去掉时间的时分秒 生成合同计划表时用
	 *
	 * @param date
	 * @return
	 */
	public static Date getTimeofDate(Date date) {
		SimpleDateFormat my = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		String str = my.format(date);
		String[] strs = str.split(" ");
		String start = strs[0] + " 00:00:00";
		Date startTime = null;
		try {
			startTime = my.parse(start);
		} catch (ParseException e) {
		}
		return startTime;
	}

	public static List<String> getPayDate(String strDate, int loanTerm) {
		List<String> list = new ArrayList<String>();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		for (int i = 1; i <= loanTerm; i++) {
			Calendar calendar = Calendar.getInstance();
			Date date2 = null;
			try {
				date2 = sdf.parse(strDate);
			} catch (ParseException e) {
				e.printStackTrace();
			}
			calendar.setTimeInMillis(date2.getTime());
			calendar.add(Calendar.MONTH, i);
			Date date = calendar.getTime();
			list.add(sdf.format(date));

		}
		return list;
	}

	/**
	 * 获取系统当前日期和时间，格式为yyyy-MM-dd HH:mm:ss
	 *
	 * @return 返回计算后的日期时间（String）
	 */
	public static String getCurrentDateTime() {
		return DateUtil.getFormatCurrentDate("yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 获取系统当前时间，格式为HH:mm:ss
	 *
	 * @return 返回计算后的时间（String）
	 */
	public static String getCurrentTime() {
		return DateUtil.getFormatCurrentDate("HH:mm:ss");
	}

	/**
	 * 获取系统当前日期，格式为yyyy-MM-dd
	 *
	 * @return 返回计算后的日期（String）
	 */
	public static String getCurrentDate() {
		return DateUtil.getFormatCurrentDate("yyyy-MM-dd");
	}

	/**
	 * 只支持"yyyy-MM-dd"和"yyyy-MM-dd HH:mm:ss"两种字符串日期转换
	 *
	 * @param stringDate
	 * @return
	 */
	public static Date format(String stringDate) {
		try {
			if (stringDate == null || "".equals(stringDate.trim())) {
				return null;
			}
			String format = "yyyy-MM-dd";
			String format_long = "yyyy-MM-dd HH:mm:ss";
			SimpleDateFormat f = null;
			if (format.length() == stringDate.length()) {
				f = new SimpleDateFormat(format);
			} else if (format_long.length() == stringDate.length()) {
				f = new SimpleDateFormat(format_long);
			}

			if (f != null) {
				return f.parse(stringDate);
			}
			return null;
		} catch (Exception e) {
			System.err.println("转换日期出错" + e.getMessage());
			e.printStackTrace();
			return null;
		}
	}

	public static boolean bigger(Date big, Date small, boolean containEquals) {
		if (big == null && small == null)
			return true;
		if (big == null || small == null)
			return false;
		long b = big.getTime();
		long s = small.getTime();
		return containEquals ? b >= s : b > s;
	}

	/********************************************/
	/************* Calendar *******************/
	/********************************************/

	/**
	 * 转换为日期 Calendar
	 *
	 * @param dateStr
	 * @return
	 */
	public static Calendar toCalendar(String dateStr, String format) {
		SimpleDateFormat dateFormat = new SimpleDateFormat(format);
		Calendar calendar = Calendar.getInstance();
		try {
			Date date = dateFormat.parse(dateStr);
			calendar.setTime(date);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return calendar;
	}

	/**
	 * 转换为日期 String
	 *
	 * @return
	 */
	public static String calendarToStr(Calendar cal) {
		int day = cal.get(Calendar.DATE); // 日
		int month = cal.get(Calendar.MONTH) + 1;// 月
		int year = cal.get(Calendar.YEAR); // 年
		return year + "-" + month + "-" + day;
	}

	/**
	 * 获取前后n个月的时间
	 *
	 * @param strFormat
	 * @return
	 * @throws ParseException
	 */
	public static Calendar mlsGetNextMonth(String strDate, String strFormat,
			int num) {
		Calendar cal = DateUtil.toCalendar(strDate, strFormat);
		cal.add(Calendar.MONTH, num);
		return cal;
	}

	/**
	 * 获取前后n个天的时间
	 *
	 * @param strFormat
	 * @return
	 * @throws ParseException
	 */
	public static Calendar mlsGetNextDay(String strDate, String strFormat,
			int num) {
		Calendar cal = DateUtil.toCalendar(strDate, strFormat);
		cal.add(Calendar.DAY_OF_MONTH, num);
		return cal;
	}

	/**
	 * 首个还款日--day
	 * @return
	 */
	public static String specifiedDate(Calendar cal, int day) {
		int month = cal.get(Calendar.MONTH) + 1;// 月
		int year = cal.get(Calendar.YEAR); // 年
		return year + "-" + month + "-" + day;
	}

	/**
	 * 根据日期获取时间戳
	 *
	 * @param date
	 *            日期
	 * @param parttern
	 *            日期格式
	 * @return
	 */
	public static long getTimeStampByDate(String date, String parttern) {
		SimpleDateFormat sdf = getDateFormat(parttern);
		Date d;
		long timeStemp = 0;
		try {
			d = sdf.parse(date);
			timeStemp = d.getTime();
		} catch (ParseException e) {
			e.printStackTrace();
		}

		return timeStemp;
	}

	/**
	 * 获取当前时间戳
	 *
	 * @return
	 */
	public static long getCurrentTimeStamp() {
		long time = System.currentTimeMillis();
		long timeStamp = time / 1000;
		return timeStamp;
	}

	/**
	 * 把时间戳转换成想要的日期格式
	 * @param date  时间戳
	 * @param parttern 日期格式
	 * @return
	 */
	public static String timeStampToStringDate(long date, String parttern) {
		if(String.valueOf(date).length()==10){
			date = Long.valueOf(date + "000");
		}
		if (StringUtils.isEmpty(parttern)) {
			parttern = "yyyy-MM-dd HH:mm:ss";
		}
		SimpleDateFormat sdf = getDateFormat(parttern);
		String returnDate = sdf.format(new Date(date));
		return returnDate;

	}

	/**
	 * 按照默认formatStr的格式，转化dateTimeStr为Date类型 dateTimeStr必须是formatStr的形式
	 * @param dateTimeStr
	 * @param formatStr
	 * @return
	 */
	public static Date strToDate(String dateTimeStr, String formatStr) {
		try {
			if (dateTimeStr == null || dateTimeStr.equals("")) {
				return null;
			}
			SimpleDateFormat sdf = getDateFormat(formatStr);
			java.util.Date d = sdf.parse(dateTimeStr);
			return d;
		} catch (ParseException e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 *
	 * @param date  需要转换的日期
	 * @param formatstr  需要转换的字符串类型
	 * @return
	 */
	public static String dateToStr(Date date, String formatstr) {
		if (StringUtils.isEmpty(formatstr)) {
			formatstr = "yyyy-MM-dd";
		}
		SimpleDateFormat sdf = getDateFormat(formatstr);
		String returnStr = sdf.format(date);
		return returnStr;

	}

	/**
	 * 判断某个日期是否在某个日期范围
	 * @param beginDate 日期范围开始
	 * @param endDate 日期范围结束
	 * @param currentDate 当前的日期
	 * @return
	 */
	public static boolean between(Date beginDate, Date endDate, Date currentDate) {
		return beginDate.before(currentDate) && endDate.after(currentDate);
	}

	/**
	 * 根据指定的时间获取月份
	 * @param date 想要得到月份的时间
	 * @return
	 */
	public static int getMonth(Date date) {
		Calendar calendar = Calendar.getInstance();
		return calendar.get(Calendar.MONTH) + 1;
	}

	/**
	 * 获取指定时间的年
	 * @param date
	 * @return
	 */
	public static int getYear(Date date) {
		Calendar calendar = Calendar.getInstance();
		return calendar.get(Calendar.YEAR);
	}

	/**
	 * 获取指定时间月的第几天
	 * @param date
	 * @return
	 */
	public static int getDayForMonth(Date date) {
		Calendar calendar = Calendar.getInstance();
		return calendar.get(Calendar.DAY_OF_MONTH);
	}

	/**
	 * 获取指定时间星期的的第几天（从周天开始算） 星期日--》星期六 对应 1--》7
	 * @param date
	 * @return
	 */
	public static int getDayForWeek(Date date) {
		Calendar calendar = Calendar.getInstance();
		return calendar.get(Calendar.DAY_OF_WEEK);
	}

	/**
	 * 计算当月最后一天,返回字符串
	 * @return
	 */
	public static String getDefaultDay() {
		String str = "";
		Calendar lastDate = Calendar.getInstance();
		lastDate.set(Calendar.DATE, 1);// 设为当前月的1号
		lastDate.add(Calendar.MONTH, 1);// 加一个月，当月
		lastDate.add(Calendar.DATE, -1);// 减去一天，变为当月最后一天
		str = sdf.format(lastDate.getTime());
		return str;
	}

	/**
	 * 计算上一个月最后一天天数,返回int
	 * @return
	 */
	public static int getPreMonthtLastDay() {

		Calendar lastDate = Calendar.getInstance();
		lastDate.set(Calendar.DATE, 1);// 设为当前月的1号
		lastDate.add(Calendar.MONTH, 0);// 0为上一个月
		lastDate.add(Calendar.DATE, -1);// 减去一天，变为当月最后一天
		return lastDate.get(Calendar.DAY_OF_MONTH);
	}

	/**
	 * 计算下一个月最后一天,返回字符串
	 * @return
	 */
	public static String getNextMonthtDay() {
		String str = "";
		Calendar NextDate = Calendar.getInstance();
		NextDate.set(Calendar.DATE, 1);// 设为当前月的1号
		NextDate.add(Calendar.MONTH, 2);// 加二个月，变为下月的1号
		NextDate.add(Calendar.DATE, -1);// 减去一天，变为当月最后一天
		str = sdf.format(NextDate.getTime());
		return str;
	}

	/**
	 * 计算指定日期当月最后一天,返回字符串
	 *
	 * @return
	 */
	public static String getDefaultDay(String strDate) {
		String str = "";
		Calendar cl = Calendar.getInstance();
		Date d = strToDate(strDate, "yyyy-MM-dd");
		cl.setTime(d);
		cl.set(Calendar.DATE, 1);// 设为当前月的1号
		cl.add(Calendar.MONTH, 1);// 加一个月，变为当月
		cl.add(Calendar.DATE, -1);// 减去一天，变为当月最后一天
		str = sdf.format(cl.getTime());
		return str;
	}

	public static String getNow() {
		// 方案一，获取数据库时间
		// Date date = basicDao.getDBNow();

		// 方案二，获取系统时间
		Date now = DateUtil.msGetCurrentDate();
		return DateUtil.msFormatDateTime(now, "yyyy-MM-dd HH:mm:ss");
	}
	/**
	 * 获取当前日期下相对n天的日期
	 * @param n
	 * @return
	 */
	public static String getNDaysDate(int n){
		Calendar cd = Calendar.getInstance(Locale.CHINA);
		cd.add(Calendar.DAY_OF_MONTH,n);
		return  DateUtil.toString(cd.getTime(),"yyyy-MM-dd");
	}
	/**
	 * 获取指定日期下相对n天的日期
	 * @param n
	 * @return
	 */
	public static Date getNDaysDate(Date d,int n){
		Calendar cd = Calendar.getInstance(Locale.CHINA);
		cd.setTime(d);
		cd.add(Calendar.DAY_OF_MONTH, n);
		return  cd.getTime();
	}
	/**
	 * 在某一个时间上添加分钟
	 * @return
	 */
	public static Long getTimeByAddAfter(String day,int min){
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date date = null;
		try {
			date = format.parse(day);
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		if (date == null)
			return 0l;
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.MINUTE, min);// 24小时制
		date = cal.getTime();
		return date.getTime()/1000;

	}

	/**
	 * 在固定时间上加月 longl
	 * @param strFormat
	 * @return
	 */
	public static String getTimeByAddMonthAfter(String dateStr,int month,String strFormat){
		Calendar cal = toCalendar(dateStr, strFormat);
		cal.add(Calendar.MONTH, month);
		return calendarToStr(cal);
	}

	/**
	 *
	 * @param date date
	 * @param field calendar 上的某个字段
	 * @param x　增量
	 * @return 10 位的long
	 */
	public static Long getTimeByCalendarField(Date date,int field,int x){
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(field, x);// 24小时制
		date = cal.getTime();
		return date.getTime()/1000;
	}

	public static Long getLastSecondByDate(Date date){
		String formatDate = DateUtil.formateDate(date,"yyyy-MM-dd");
		return DateUtil.getTimeStampByDate(formatDate+" 23:59:59", "yyyy-MM-dd hh:mm:ss");
	}

	/**对时间进行操作判断是否超时
	 * 
	 * @param applyTime
	 * @throws Exception
	 */
	public static String ifTime(String applyTime)
	{
		//判断是否让客户申请放款
		String time = DateUtil.msFormatDateTime(new Date(),"");
		
		String[] times = time.split(" ");
		
		int cach=applyTime.compareTo(times[0]);
		if(cach<0) {
			return "申请时间请选择在当天之后，申请时间不能为当天之前";
		}else if(cach==0){
			String[] HMS = times[1].split(":");
			if(Integer.valueOf(HMS[0]) >= 16)
			{
				return "当天的申请时间不能超过下午4点，请在4点之前打印单子";
			}
		}
		return null;
		
	}
	
	   /**
	    * 获取本周周一时间戳
	    * @return
	    */
	   public static long getCurrentWeekFirstDay(){
		   return getTimeStampByDate(getMondayOfThisWeek(), "yyyy-MM-dd")/1000;
	   }
	   
	   /**
	    * 获取本周周日时间戳
	    */
	   public static long getCurrentWeekLastDay(){
		  return getTimeStampByDate(getSundayOfThisWeek(), "yyyy-MM-dd")/1000;
	   }
	   
	   /**
	    * 得到本周周日
	    * 
	    * @return yyyy-MM-dd
	    */
	   public static String getSundayOfThisWeek() {
	    Calendar c = Calendar.getInstance();
	    int day_of_week = c.get(Calendar.DAY_OF_WEEK) - 1;
	    if (day_of_week == 0)
	     day_of_week = 7;
	    c.add(Calendar.DATE, -day_of_week + 7);
	    return getParseDate("yyyy-MM-dd",c.getTime());
	   }
	   
	   
	   /**
	    * 得到本周周一
	    * 
	    * @return yyyy-MM-dd
	    */
	   public static String getMondayOfThisWeek() {
	    Calendar c = Calendar.getInstance();
	    int day_of_week = c.get(Calendar.DAY_OF_WEEK) - 1;
	    if (day_of_week == 0)
	     day_of_week = 7;
	    c.add(Calendar.DATE, -day_of_week + 1);
	    return getParseDate("yyyy-MM-dd",c.getTime());
	   }

	   /**
	    * 获取当月第一天时间戳
	    * @return
	    */
	   public static long getCurrentMonthFirstDay(){
		   Calendar cal = Calendar.getInstance(); 
		   cal.setTime(new Date()); 
		   cal.set(Calendar.DAY_OF_MONTH, 1); 
		   return getTimeStampByDate(new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime()), "yyyy-MM-dd")/1000;
	   }
	   
	   /**
	    * 获取当月最后一天时间戳
	    * @return
	    */
	   public static long getCurrentMonthLastDay(){
		  Calendar cal = Calendar.getInstance(); 
		  cal.setTime(new Date()); 
		  cal.set(Calendar.DAY_OF_MONTH, 1); 
		  cal.roll(Calendar.DAY_OF_MONTH, -1);  
		  return  getTimeStampByDate(new SimpleDateFormat("yyyy-MM-dd").format(cal.getTime()), "yyyy-MM-dd")/1000;
	   }
	   
	   /**
	    * 获取当月第一天的年日月时分秒
	    * @return
	    */
	   public static String getCurrentMonthFirstDayFormat(){
		   Calendar cal = Calendar.getInstance(); 
		   cal.setTime(new Date()); 
		   cal.set(Calendar.DAY_OF_MONTH, 1); 
		   return new SimpleDateFormat("yyyy-MM-dd 00:00:00").format(cal.getTime());
	   }
	   
	   /**
	    * 获取当月最后一天年日月时分秒
	    * @return
	    */
	   public static String getCurrentMonthLastDayFormat(){
		  Calendar cal = Calendar.getInstance(); 
		  cal.setTime(new Date()); 
		  cal.set(Calendar.DAY_OF_MONTH, 1); 
		  cal.roll(Calendar.DAY_OF_MONTH, -1);  
		  return new SimpleDateFormat("yyyy-MM-dd 24:00:00").format(cal.getTime());
	   }
	   


	public static void main(String[] args) {
		//getTimeStampByDate
		//long t=getTimeStampByDate("2015-09-27", "yyyy-MM-dd");
		//System.out.println(t);
		/*Long a =getTimeByAddAfter(getCurrentTime("yyyy-MM-dd HH:mm:ss"),20);
		String b=timeStampToStringDate(a,"yyyy-MM-dd hh:mm:ss");
		System.out.println(b);*/

		//	String t=timeStampToStringDate(1444934589,"yyyy-MM-dd HH:mm:ss");
		//System.out.println(t);
		String d= getCurrentDateTime();
		System.out.println(d);
	}

}